/**
 * 
 */
package br.org.bertol.mestrado.engine.optimisation.moo;

import java.util.EnumMap;

import br.org.bertol.mestrado.engine.Objective;

/**
 * @author contaqualquer
 */
public class ParetoMinMaxDominace extends
        ParetoDominace<EnumMap<Objective, Number>> {

    @Override
    public final int compare(final EnumMap<Objective, Number> left,
            final EnumMap<Objective, Number> right) {

        int lessSecond = 0, biggerSecond = 0, lessFirst = 0, biggerFirst = 0, equal = 0;

        final Objective[] objectives = left.keySet()
                .toArray(new Objective[] {});

        // caso ambos sejam iguais
        // retorna n�o domin�ncia

        for (int i = 0; i < objectives.length; i++) {

            final int leftV = left.get(objectives[i]).intValue();

            final int rightV = right.get(objectives[i]).intValue();

            // verifica primeiro objetivo
            // esquerda menor que direita
            if (i == 0) {
                if (rightV < leftV) {
                    biggerFirst += 1;
                } else if (leftV < rightV) {
                    lessFirst += 1;
                } else {
                    equal += 1;
                }
            } else {
                // verifica segundo objetivo
                // esquerda maior que direita
                if (rightV > leftV) {
                    lessSecond += 1;
                } else if (leftV > rightV) {
                    biggerSecond += 1;
                } else {
                    equal += 1;
                }
            }
        }

        // caso encerre o la�o e o flag seja true
        // ent�o left n�o � pior em nenhuma solu��o e � melhor em pelo menos uma
        if ((lessFirst > 0 && biggerSecond > 0) || (lessFirst > 0 && equal > 0)
                || (biggerSecond > 0 && equal > 0)) {
            return LEFT_DOMINE;
        }
        if ((biggerFirst > 0 && lessSecond > 0)
                || (biggerFirst > 0 && equal > 0)
                || (lessSecond > 0 && equal > 0)) {
            return RIGHT_DOMINE;
        }

        // caso contr�rio, left n�o domina right
        return LEFT_DONT_DOMINE;
    }
}
